﻿using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

using System.Data;
using C1.Win.C1FlexGrid;
using C1.C1Preview;
using System.Drawing.Printing;
using ACControles;


namespace ACReporteador
{
    /// <summary>
    /// Clase que permite generar reportes usando controles como C1FlexGrid, DataTable y DataSet
    /// </summary>
   public partial class ACPreview : Form
   {
      #region Variables

      private ACListaFlex m_listaC1FlexGrid;
      private ACCeldaCombinadaListaLista m_celdaCombinadaListaLista;
      private ACColumnaAlineacionLista m_columnaAlineacionLista;
      private ACColumnaAlineacion m_columnaAlineacion;      
      private ACCabecera m_cabecera;
      private ACMargen m_margen;
      private ACPiePagina m_footer;
      private ACEstilo m_style;      
      private ACTexto m_texto;
      private ACTextoLista m_textoLista;
      private ACTablaAncho m_anchoTabla;
      private PaperKind m_tipoPapel;

      //private bool data;
      //private int option;

      private string titleDialog = "";

      #endregion

      #region Propiedades

      public PaperKind ACTipoPapel
      {
         get { return m_tipoPapel; }
         set { m_tipoPapel = value; }
      }
      /// <summary>
      /// Lista que contiene los listados de coordenadas de celdas que fueron unidas, usado para multiples grid que puedas estar siendo enviadas
      /// </summary>
      public ACCeldaCombinadaListaLista ACListaCeldas
      {
         get { return m_celdaCombinadaListaLista; }
         set { m_celdaCombinadaListaLista = value; }
      }
      /// <summary>
      /// Para asignar la cabecera del reportes, que puede haber sido construida previamente
      /// </summary>
      public ACCabecera ACCabecera
      {
         get { return m_cabecera; }
         set { m_cabecera = value; }
      }
      /// <summary>
      /// Estilo del reporte, aqui se asignan los estilos que pueden haber sido definidos para todo el reporte
      /// </summary>
      public ACEstilo ACEstiloReporte
      {
         get { return m_style; }
         set { m_style = value; }
      }
      /// <summary>
      /// Aqui se asignan los margenes del reportes, los margenes de la hoja
      /// </summary>
      public ACMargen ACMargen
      {
         get { return m_margen; }
         set { m_margen = value; }
      }
      /// <summary>
      /// Aqui se asigna el pie de pagina del reporte
      /// </summary>
      public ACPiePagina ACPiePagina
      {
         get { return m_footer; }
         set { m_footer = value; }
      }
      /// <summary>
      /// Aqui s asigna las propiedades de las columnas de una sola grilla
      /// </summary>
      public ACColumnaAlineacion ACColumnas
      {
         get { return m_columnaAlineacion; }
         set { m_columnaAlineacion = value; }
      }

      /// <summary>
      /// Aqui se asigna las propiedaesde las las columnas, pero agrupadas en listas para multiples grillas
      /// </summary>
      public ACColumnaAlineacionLista ACColumnasLista
      {
         get { return m_columnaAlineacionLista; }
         set { m_columnaAlineacionLista = value; }
      }
      public ACTextoLista ACTextoLista
      {
         get { return m_textoLista; }
         set { m_textoLista = value; }
      }
      public ACTablaAncho ACTablaAncho
      {
         get { return m_anchoTabla; }
         set { m_anchoTabla = value; }
      }
      #endregion

      #region Constructores

      /// <summary>
      /// Inicializa todas las clases que no fueron inicializadas y/o cambiadas en la creaccion
      /// del reporte
      /// </summary>
      private void Inicializar()
      {
         m_margen = new ACMargen();
         m_style = new ACEstilo();
         m_cabecera = new ACCabecera();
         m_footer = new ACPiePagina();
         m_texto = new ACTexto();
         m_textoLista = new ACTextoLista();
         titleDialog = "Previsualizar Reporte";
      }

      public ACPreview()
      {
         InitializeComponent();
         m_listaC1FlexGrid = new ACListaFlex();
         m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();
         
         m_cabecera = new ACCabecera();
         m_margen = new ACMargen();
         m_tipoPapel = PaperKind.A4;
      }

      #region Constructores Basicos
      public ACPreview(C1FlexGrid x_flex, ACCabecera x_header)
      {
         InitializeComponent();
         try
         {
            m_listaC1FlexGrid = new ACListaFlex();
            m_listaC1FlexGrid.Add(x_flex);

            m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();
            //option = 0;

            m_cabecera = new ACCabecera(x_header);
            m_margen = new ACMargen();
            m_tipoPapel = PaperKind.A4;
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      #endregion

      #region Constructores Flex
      /// <summary>
      /// Constructor base, carga los datos a ser procesados
      /// </summary>
      /// <param name="x_flex">Grilla de C1 enviada po valor, para extraer los datos</param>
      /// <param name="x_cell">Lista Generica que contiene las coordenadas de las celdas unidas</param>
      /// <param name="x_header">Contenedor de los datos basicos de la cabecera</param>
      public ACPreview(C1FlexGrid x_flex, ACCeldaCombinadaLista x_cell, ACCabecera x_header)
      {
         InitializeComponent();
         m_listaC1FlexGrid = new ACListaFlex();
         m_listaC1FlexGrid.Add(x_flex);

         m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();
         //option = 0;
         
         m_cabecera = new ACCabecera(x_header);
         m_margen = new ACMargen();
         m_tipoPapel = PaperKind.A4;
      }
      #endregion

      #region Contructor de Multiples Flex
      /// <summary>
      /// Contructor basico del Lista de FlexGrid
      /// </summary>
      /// <param name="x_flex">Lista de FlexGrid</param>
      /// <param name="x_header">Cabecera del Reporte</param>
      public ACPreview(ACListaFlex x_flex, ACCabecera x_header)
      {
         InitializeComponent();
         m_listaC1FlexGrid = new ACListaFlex(x_flex);

         m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();
         
         
         m_cabecera = new ACCabecera(x_header);
         m_margen = new ACMargen();
         m_tipoPapel = PaperKind.A4;
      }
      /// <summary>
      /// Constructor base, carga los datos a ser procesados
      /// </summary>
      /// <param name="x_flex">Grilla de C1 enviada po valor, para extraer los datos</param>
      /// <param name="x_cell">Lista Generica que contiene las coordenadas de las celdas unidas</param>
      /// <param name="x_header">Contenedor de los datos basicos de la cabecera</param>
      public ACPreview(ACListaFlex x_flex, ACCeldaCombinadaListaLista x_cell, ACCabecera x_header)
      {
         InitializeComponent();
         m_listaC1FlexGrid = new ACListaFlex(x_flex);

         m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista(x_cell);
         
         
         m_cabecera = new ACCabecera(x_header);
         m_margen = new ACMargen();
         m_tipoPapel = PaperKind.A4;
      }
      #endregion

      #region constructores Datatable
      /// <summary>
      /// Constructor que recibe un data table y genera un reporte
      /// </summary>
      /// <param name="x_data">Data Table</param>
      /// <param name="x_header">Clase Cabecera</param>
      public ACPreview(DataTable x_data, ACCabecera x_header)
      {
         InitializeComponent();
         try
         {
            C1FlexGrid m_flex = new C1FlexGrid();
            crearFlex(x_data, ref m_flex);
            m_listaC1FlexGrid = new ACListaFlex();
            m_listaC1FlexGrid.Add(m_flex);
            m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();
            //option = 0;
            
            m_cabecera = new ACCabecera(x_header);
            m_margen = new ACMargen();
            m_tipoPapel = PaperKind.A4;
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      public ACPreview(DataSet x_data, ACCabecera x_header)
      {
         InitializeComponent();
         m_listaC1FlexGrid = new ACListaFlex();

         for (int i = 0; i < x_data.Tables.Count; i++)
         {
            m_listaC1FlexGrid.Add(crearFlex(x_data.Tables[i]));
         }

         m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();
         
         
         m_cabecera = new ACCabecera(x_header);
         m_margen = new ACMargen();
         m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();
         m_tipoPapel = PaperKind.A4;
      }
      #endregion

      #region Metodos Utiles
      /// <summary>
      /// Construye un Control C1Flexgrid desde un control DataTable
      /// </summary>
      /// <param name="x_data">DataTable que contiene los datos para construir un control C1FlexGrid</param>
      /// <returns>Control C1FlexGrid</returns>
      public C1FlexGrid crearFlex(DataTable x_data)
      {
         C1FlexGrid x_flex = new C1FlexGrid();
         ((System.ComponentModel.ISupportInitialize)(x_flex)).BeginInit();
         x_flex.ColumnInfo = "9,1,0,0,0,85,Columns:0{Width:20;}\t1{Caption:\"a\";}\t2{Caption:\"b\";}\t3{Width:46;Caption:\"c\";}\t";
         x_flex.Dock = System.Windows.Forms.DockStyle.Fill;
         x_flex.Location = new System.Drawing.Point(0, 44);
         x_flex.Name = "_flex";
         x_flex.Rows.Count = 10;
         x_flex.Rows.DefaultSize = 17;
         x_flex.Size = new System.Drawing.Size(670, 302);
         x_flex.TabIndex = 1;

         this.Controls.Add(x_flex);
         ((System.ComponentModel.ISupportInitialize)(x_flex)).EndInit();
         x_flex.Styles.Normal.WordWrap = false;
         x_flex.AutoGenerateColumns = true;
         x_flex.DataSource = x_data;
         x_flex.Visible = true;

         x_flex.Cols[0].Visible = false;
         return x_flex;
      }
      /// <summary>
      /// Construye un Control C1Flexgrid desde un control DataTable
      /// </summary>
      /// <param name="x_data">DataTable que contiene los datos para construir un control C1FlexGrid</param>
      /// <param name="x_flex">Control C1FlexGrid</param>
      public void crearFlex(DataTable x_data, ref C1FlexGrid x_flex)
      {
         x_flex = new C1FlexGrid();
         ((System.ComponentModel.ISupportInitialize)(x_flex)).BeginInit();
         x_flex.ColumnInfo = "9,1,0,0,0,85,Columns:0{Width:20;}\t1{Caption:\"a\";}\t2{Caption:\"b\";}\t3{Width:46;Caption:\"c\";}\t";
         x_flex.Dock = System.Windows.Forms.DockStyle.Fill;
         x_flex.Location = new System.Drawing.Point(0, 44);
         x_flex.Name = "_flex";
         x_flex.Rows.Count = 10;
         x_flex.Rows.DefaultSize = 17;
         x_flex.Size = new System.Drawing.Size(670, 302);
         x_flex.AutoGenerateColumns = true;
         //x_flex.TabIndex = 1;

         //this.Controls.Add(x_flex);
         ((System.ComponentModel.ISupportInitialize)(x_flex)).EndInit();
         x_flex.Styles.Normal.WordWrap = false;
         x_flex.DataSource = x_data;
         x_flex.Visible = true;

         x_flex.Cols[0].Visible = false;
      }
      /// <summary>
      /// Iniciar Variables
      /// </summary>
      private void InicializarVariables()
      {
         if (m_margen == null) { m_margen = new ACMargen(); }
         if (m_style == null) { m_style = new ACEstilo(); }
         if (m_cabecera == null) { m_cabecera = new ACCabecera(); }
         if (m_footer == null) { m_footer = new ACPiePagina(); }
         if (m_anchoTabla == null) { m_anchoTabla = new ACTablaAncho(1, UnitTypeEnum.Cm); }
      }
      #endregion

      #endregion

      #region Metodos

      /// <summary>
      /// Generar la Cabecera del reporte
      /// </summary>
      /// <returns>Objeto que contiene la cabecera preparada.</returns>
      private RenderParagraph GenerarCabecera()
      {
         RenderParagraph _rp = new RenderParagraph();
         try
         {
            _rp.Style.FontBold = true;
            _rp.Style.FontName = m_style.FuenteTipo;
            _rp.TabPositions.Add(new C1.C1Preview.TabPosition("width / 2", TabAlignmentEnum.Center));
            _rp.TabPositions.Add(new C1.C1Preview.TabPosition("width", TabAlignmentEnum.Right));

            String line1 = m_cabecera.SucursalTitulo.Texto + m_cabecera.SeparadorSucursal + m_cabecera.Sucursal.Texto;
            _rp.Content.AddText(line1, m_cabecera.SucursalTitulo.Fuente);
            _rp.Content.AddText("\t\t");
            _rp.Content.AddText(String.Format("Fecha : {0}", m_cabecera.FechaHora), m_cabecera.SucursalTitulo.Fuente);
            _rp.Content.AddText("\r");

            String line2 = m_cabecera.RucTitulo.Texto + m_cabecera.SeparadorRuc + m_cabecera.Ruc.Texto;
            _rp.Content.AddText(line2, m_cabecera.RucTitulo.Fuente);
            _rp.Content.AddText("\t\t");
            _rp.Content.AddText("Pagina : [PageNo] / [PageCount]", m_cabecera.RucTitulo.Fuente);
            _rp.Content.AddText("\r");

            if (m_cabecera.LogoTitulo != null)
            {
               _rp.Content.AddImage(m_cabecera.LogoTitulo);
               _rp.Content.AddText("\r");
            }

            
            //_rp.Content.AddImage(ACReporteador.Properties.Resources.Logo_Titulo_reducido_600x70);
            

            _rp.Content.AddText("\t");
            _rp.Content.AddText(m_cabecera.Titulo.Texto, m_cabecera.Titulo.Fuente);
            _rp.Content.AddText("\t");
            _rp.Content.AddText("\r");
            

            if (m_cabecera.TitulosExtras != null)
            {
               foreach (ACTexto Item in m_cabecera.TitulosExtras)
               {
                  _rp.Content.AddText("\t");
                  _rp.Content.AddText(Item.Texto, Item.Fuente);
                  _rp.Content.AddText("\t");
                  _rp.Content.AddText("\r");
               }
            }

            if (m_cabecera.SubTitulo != null)
            {
               foreach (ACTexto Item in m_cabecera.SubTitulo)
               {
                  _rp.Content.AddText(Item.Texto, Item.Fuente);
                  _rp.Content.AddText("\t");
                  _rp.Content.AddText("\t");
                  _rp.Content.AddText("\r");
               }
            }
            _rp.Content.AddText(Environment.NewLine);            
         }
         catch (Exception ex)
         {
            throw ex;
         }
         return _rp;
      }
      #endregion

      #region Eventos Publicos

      #region Generar la Cabecera

      /// <summary>
      /// Definir la cabecera, con los datos basicos.
      /// </summary>
      /// <remarks>
      /// Los datos requeridos aqui son los necesarios para poder generar la cabecera del
      /// reporte, los datos aqui requeridos son los minimos que se necesitan, para lo
      /// cual se necesita ingresar un caracter o simplemente una cadena vacia.
      /// </remarks>
      /// <param name="_title">Titulo del Reporte, El titulo ocupa la tercera linea y
      /// alineado a al centro</param>
      /// <param name="_sucursal">Sucursal, Ubicada en el lado superior izquierdo del
      /// reporte, en la primera linea del reporte</param>
      /// <param name="_ruc">R.U.C., Ubicado al lado superior izquierdo, debajo de la
      /// sucursal, ocupando la segunda linea del reporte</param>
      /// <example>
      /// En el siguiente ejemplo podemos apreciar la forma mas rapida asignar la cabecera
      /// al reporte que se desea crear. 
      /// <para></para>
      /// <code>nsPreview x = new nsPreview();
      /// x.setHeader("Titulo", "Sucursal", "ruc");</code>
      /// </example>
      /// <author>Ysaacx</author>
      /// <version>1.0.1</version>
      public void setCabecera(ACTexto _title, string _sucursal, string _ruc, Font x_fuente)
      {
         try
         {
            m_cabecera = new ACCabecera(_title, _sucursal, _ruc, x_fuente);
         }
         catch (Exception ex)
         {
            ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede generar la cabecera", ex);
         }
      }

      /// <summary>
      /// Definir la cabecera con sus todos los datos que se muestran en el reporte, los cuales se explican en la parte posterior.
      /// </summary>
      /// <param name="_title">titulo del reporte, ubicado en la tercera linea en la parte central del documento</param>
      /// <param name="_subtitle">Un array con los subtitulos, se ubican en la siguientes lineas despues del titulo, alineados
      /// hacia el lado izquierdo</param>
      /// <param name="_sucursal">Sucursal, Ubicada en el lado superior izquierdo del reporte, en la primera linea</param>
      /// <param name="_ruc">R.U.C., Ubicado al lado superior izquierdo, debajo de la sucursal, en la segunda linea</param>
      /// <param name="_dateShow">Fecha que se mostrara en el reporte, en la parte superior derecha, de la primera linea</param>
      /// <remarks>En esta funcion se muestran todas las opciones disponibles para la cabecera del reporte, tambien existe un espacio 
      /// para el numero de pagina del reporte, que se ubica en la segunda linea en el extremo derecho, debajo de la fecha que se
      /// mostrara, la cual depende de la fecha que le ingresemos.</remarks>
      /// <example>
      /// <code>nsPreview x = new nsPreview();
      /// string[] subtitle ={ "Subtitle 1", "Subtitle 2" };
      /// x.setHeader("Titulo", subtitle, "Sucursal", "ruc", DateTime.Now);</code>
      /// </example>
      public void setCabecera(ACTexto _title, ACTexto[] _subtitle, string _sucursal, string _ruc, DateTime _dateShow, Font x_fuente)
      {
         try
         {
            m_cabecera = new ACCabecera(_title, _sucursal, _ruc, _subtitle, _dateShow, x_fuente);
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede generar la cabecera", ex);
         }
      }

      /// <summary>
      /// Para añadir mas titulos al reporte
      /// </summary>
      /// <param name="_extra">Array que debe contener el resto de subtitulos que se desea.</param>
      /// <remarks>Los titulos extra suponen colocar lineas de texto centrados ubicados despues del titulo principal, podemos 
      /// recalcar que se ubicaran entre el titulo principal y los subitulos que puedan ingresarse.</remarks>
      /// <example>Podemos ver en el siguiente ejemplo, un uso de esta funcion que permitira aclarar el uso de de esta funcion
      /// <code>nsPreview x = new nsPreview();
      /// x.setHeader("Titulo", "Sucursal", "ruc");
      /// string[] titulos ={ "Titulo 2", "Titulo 3" };
      /// x.setHeader(titulos);</code></example>
      public void setCabecera(ACTexto[] _extra)
      {
         try
         {
            m_cabecera.TitulosExtras = _extra;
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede generar la cabecera", ex);
         }
      }
      #endregion

      #region Generar pie de pagina
      /// <summary>
      /// Definir el pie de pagina
      /// </summary>
      /// <param name="_footer">Texto que va como pie de pagina</param>
      public void setPiePagina(string _footer)
      {
         try
         {
            m_footer = new ACPiePagina(_footer);
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }
      #endregion

      #region Colocar margen de la pagina

      /// <summary>
      /// Definir el margen del documento reporte, usando un array de 4 elementos.
      /// </summary>
      /// <param name="_margen">Array de Double que contiene los margenes en el siguiente orden:
      /// <para>- Arriba: Top</para>
      /// <para>- Derecha: Right</para>
      /// <para>- Izquierda: Left</para>
      /// <para>- Abajo: Bottom</para></param>
      /// <example>El siguiente ejemplo muestra la forma practica de colocar los margenes
      /// <code>nsPreview x = new nsPreview();
      /// double[] margenes = { 20.0, 20.0, 20.0, 20.0 };
      /// x.setMargen(margenes);</code></example>
      public void setMargen(double[] _margen)
      {
         try
         {
            if (_margen.Length == 4)
            {
               m_margen = new ACMargen(_margen[0], _margen[1], _margen[2], _margen[3]);
            }
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }

      /// <summary>
      /// Definir el margen del documento reporte, usando un array de 4 elementos, y la unidad en la que se medira.
      /// </summary>
      /// <param name="_margen">Array de Double que contiene los margenes en el siguiente orden:
      /// <para>- Arriba: Top</para>
      /// <para>- Derecha: Right</para>
      /// <para>- Izquierda: Left</para>
      /// <para>- Abajo: Bottom</para></param>
      /// <param name="_united">Unidad en la que se expresara el margen ingresado</param>
      /// <example>El siguiente ejemplo muestra la forma practica de colocar los margenes
      /// <code>nsPreview x = new nsPreview();
      /// double[] margenes = { 20.0, 20.0, 20.0, 20.0 };
      /// x.setMargen(margenes, UnitTypeEnum.Mm);</code></example>
      public void setMargen(double[] _margen, UnitTypeEnum _united)
      {
         try
         {
            if (_margen.Length == 4)
            {
               m_margen = new ACMargen(_margen[0], _margen[1], _margen[2], _margen[3], _united);
            }
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }

      /// <summary>
      /// Definir el margen de un documento reporte, enviando las medidas individualmente
      /// </summary>
      /// <param name="_top">Margen superior: arriba</param>
      /// <param name="_right">Margen derecho: derecha</param>
      /// <param name="_left">Margen izquierdo: izquierda</param>
      /// <param name="_bottom">Margen inferior: abajo</param>
      /// <example>la forma directa de colocar los margenes, en el ejemplo veremos que la unidad por defecto sera en milimetros.
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setMargen(20.0, 20.0, 20.0, 20.0);</code></example>
      /// <remarks>Con respecto a esta funcion tenemos que tener en cuenta que al colocar los margenes sin indicar en que unidad
      /// se va a medir, se toma por defecto que sera medidos en milimetros.</remarks>
      public void setMargen(double _top, double _right, double _left, double _bottom)
      {
         try
         {
            m_margen = new ACMargen(_top, _right, _left, _bottom);
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }

      /// <summary>
      /// Definir el margen de un documento reporte, enviando las medidas individualmente, junto con la unidad de medida
      /// </summary>
      /// <param name="_top">Margen superior: arriba</param>
      /// <param name="_right">Margen derecho: derecha</param>
      /// <param name="_left">Margen izquierdo: izquierda</param>
      /// <param name="_bottom">Margen inferior: abajo</param>
      /// <param name="_united">Unidad en la que se expresara el margen ingresado</param>
      /// <example>la forma directa de colocar los margenes
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setMargen(20.0, 20.0, 20.0, 20.0, UnitTypeEnum.Mm);</code></example>
      public void setMargen(double _top, double _right, double _left, double _bottom, UnitTypeEnum _united)
      {
         try
         {
            m_margen = new ACMargen(_top, _right, _left, _bottom, _united);
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }
      #endregion

      #region Colocar el estilo

      #region Estilo de Linea
      /// <summary>
      /// Colocar el estilo de linea que tendran las tablas de los reportes, se tiene que usar el objeto LineDef del la clase C1.C1Preview.
      /// Para usar estas funciones es necesario haber definido el estilo, para que no 
      /// de errores en su uso
      /// </summary>
      /// <param name="_styleLine">Objeto tipo Linea</param>
      /// <example>Tipo de linea
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setStyle(NSEStyle.modern, false);
      /// LineDef line = new LineDef("2pt", Color.Blue);
      /// x.setStyleLine(line);</code></example>
      /// <remarks>Existen multiples formas de implementar el tipo de linea, y todo esta subeditado a la clase LineDef</remarks>
      public void setEstiloLinea(LineDef _styleLine)
      {
         try
         {
            if (m_style != null)
               m_style.LineaEstilo = _styleLine;
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Colocar el estilo de linea que tendran las tablas de los reportes, tiene que colocar el tipo de linea como una cadena y el color como
      /// un objeto.
      /// Para usar estas funciones es necesario haber definido el estilo, para que no 
      /// de errores en su uso
      /// </summary>
      /// <param name="_line">Grosor de la linea ejem "0.5pt"</param>
      /// <param name="_color">el color de la linea ejem: Color.Black</param>
      /// <example>Tipo de linea
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setStyle(NSEStyle.modern, false);
      /// x.setStyleLine("2pt", Color.Blue);</code></example>
      /// <remarks>Existen multiples formas de implementar el tipo de linea, y todo esta subeditado a la clase LineDef</remarks>
      public void setEstiloLinea(string _line, Color _color)
      {
         try
         {
            if (m_style != null)
               m_style.LineaEstilo = new LineDef(_line, _color);
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }
      #endregion

      #region Padding

      /// <summary>
      /// El padding es el espacio de relleno que hay despues del especio dejado por los margenes, usando un arreglo
      /// de string.
      /// </summary>
      /// <param name="_padding">Arreglo que contiene los padding para cada lado, se tiene que ingresar en el
      /// siguiente orden:
      /// <para>- Top:</para> Arriba
      /// <para>- Right:</para> Derecha
      /// <para>- Left:</para> Izquierda
      /// <para>- Bottom:</para> Abajo</param>
      /// <example>El siguiente ejemplo muestra como colocar los padding de forma directa
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setStyle(NSEStyle.modern, false);
      /// string[] padd = { "5mm", "5mm", "5mm", "5mm" };
      /// x.setPadding(padd);</code></example>
      public void setPadding(string[] _padding)
      {
         try
         {
            if (m_style != null)
            {
               if (_padding.Length == 4)
               {
                  m_style.PaddingArriba = _padding[0];
                  m_style.PaddingDerecha = _padding[1];
                  m_style.PaddingIzquierda = _padding[2];
                  m_style.PaddingAbajo = _padding[3];
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// El padding es el espacio de relleno que hay despues del especio dejado por los margenes, ingresando lado
      /// </summary>
      /// <param name="_top">Arriba</param>
      /// <param name="_right">Derecha</param>
      /// <param name="_left">Izquierda</param>
      /// <param name="_bottom">Abajo</param>
      /// <example>El siguiente ejemplo muestra la forma de ingresar los padding directamente
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setStyle(NSEStyle.modern, false);
      /// x.setPadding("5mm", "5mm", "5mm", "5mm");</code></example>
      public void setPadding(string _top, string _right, string _left, string _bottom)
      {
         try
         {
            if (m_style != null)
            {
               m_style.PaddingArriba = _top;
               m_style.PaddingDerecha = _right;
               m_style.PaddingIzquierda = _left;
               m_style.PaddingAbajo = _bottom;
            }
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }

      /// <summary>
      /// Un arreglo de unidades para el relleno de espacios despues de los margenes
      /// </summary>
      /// <param name="padding">Arreglo del tipo Unit</param>
      /// <example>El Siguiente ejemplo nos muestra como colocar los padding usando un arreglo de unidades
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// Unit[] u = { new Unit(5.0, UnitTypeEnum.Mm), new Unit(5.0, UnitTypeEnum.Mm), new Unit(5.0, UnitTypeEnum.Mm), new Unit(5.0, UnitTypeEnum.Mm) };
      /// x.setPadding(u);</code></example>
      public void setPadding(Unit[] padding)
      {
         try
         {
            if (m_style != null)
            {
               if (padding.Length == 4)
               {
                  m_style.PaddingArriba = padding[0].Value.ToString() + padding[0].Units.ToString().ToLower();
                  m_style.PaddingDerecha = padding[1].Value.ToString() + padding[1].Units.ToString().ToLower();
                  m_style.PaddingIzquierda = padding[2].Value.ToString() + padding[2].Units.ToString().ToLower();
                  m_style.PaddingAbajo = padding[3].Value.ToString() + padding[3].Units.ToString().ToLower();
               }
            }
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }

      /// <summary>
      /// Las unidades para el relleno de espacios despues de los margenes
      /// </summary>
      /// <param name="_top">Arriba</param>
      /// <param name="_right">Derecha</param>
      /// <param name="_left">Izquierda</param>
      /// <param name="_bottom">Abajo</param>
      /// <example>El siguiente ejemplo muestra la forma de ingresar las unidades de forma directa
      /// <code>nsPreview x = new nsPreview();
      /// ...
      ///  x.setStyle(NSEStyle.modern, false);
      ///  x.setPadding(new Unit(5.0, UnitTypeEnum.Mm), new Unit(5.0, UnitTypeEnum.Mm), new Unit(5.0, UnitTypeEnum.Mm), new Unit(5.0, UnitTypeEnum.Mm));</code></example>
      public void setPadding(Unit _top, Unit _right, Unit _left, Unit _bottom)
      {
         try
         {
            if (m_style != null)
            {
               m_style.PaddingArriba = _top.Value.ToString() + _top.Units.ToString().ToLower();
               m_style.PaddingDerecha = _right.Value.ToString() + _right.Units.ToString().ToLower();
               m_style.PaddingIzquierda = _left.Value.ToString() + _left.Units.ToString().ToLower();
               m_style.PaddingAbajo = _bottom.Value.ToString() + _bottom.Units.ToString().ToLower();
            }
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }

      /// <summary>
      /// El padding es el espacio de relleno que hay despues del espacio dejado por los margenes, y el espacio que hay
      /// entre la lineas y el texto de cada celda, usando string como dimensiones
      /// </summary>
      /// <param name="_padding_all">Espacio para todos los lados del reporte</param>
      /// <param name="_cell_padding_all">Espacio de todos los lados de cada celda</param>
      /// <example>El siguiente ejemplo no smuestar la forma de usar la funcion de los espacios.
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setStyle(NSEStyle.modern, false);
      /// x.setPaddingAll("5mm", "5mm");</code></example>
      public void setPaddingTodos(string _padding_all, string _cell_padding_all)
      {
         try
         {
            if (m_style != null)
            {
               m_style.PaddingTodos = _padding_all;
               m_style.PaddingCeldaTodos = _cell_padding_all;
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Definir los espacios de las celdas del documento, se debe haber definido el estilo o ejecutado setStyle.
      /// </summary>
      /// <param name="_top">Arriba</param>
      /// <param name="_right">Derecha</param>
      /// <param name="_left">Izquierda</param>
      /// <param name="_bottom">Abajo</param>
      /// <example>El siguiente ejemplo muestra la forma de colocar los espacios en la celda
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setStyle(NSEStyle.modern, false);
      /// x.setPaddingCell("5mm", "5mm", "5mm", "5mm");</code></example>
      public void setPaddingCeldas(string _top, string _right, string _left, string _bottom)
      {
         try
         {
            if (m_style != null)
            {
               m_style.PaddingCeldaArriba = _top;
               m_style.PaddingCeldaDerecha = _right;
               m_style.PaddingCeldaIzquierda = _left;
               m_style.PaddingCeldaAbajo = _bottom;
            }
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }

      /// <summary>
      /// Definir los espacios de las celdas del documento, se debe haber definido el estilo o ejecutado setStyle.
      /// </summary>
      /// <param name="_top">Arriba</param>
      /// <param name="_right">Derecha</param>
      /// <param name="_left">Izquierda</param>
      /// <param name="_bottom">Abajo</param>
      /// <example>El siguiente ejemplo muestra la forma de colocar los espacios en la celda
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setStyle(NSEStyle.modern, false);
      /// x.setPaddingCell(new Unit(5.0, UnitTypeEnum.Mm), new Unit(5.0, UnitTypeEnum.Mm), new Unit(5.0, UnitTypeEnum.Mm), new Unit(5.0, UnitTypeEnum.Mm));</code></example>
      public void setPaddingCeldas(Unit _top, Unit _right, Unit _left, Unit _bottom)
      {
         try
         {
            if (m_style != null)
            {
               m_style.PaddingCeldaArriba = _top.Value.ToString() + _top.Units.ToString().ToLower();
               m_style.PaddingCeldaDerecha = _right.Value.ToString() + _right.Units.ToString().ToLower();
               m_style.PaddingCeldaIzquierda = _left.Value.ToString() + _left.Units.ToString().ToLower();
               m_style.PaddingCeldaAbajo = _bottom.Value.ToString() + _bottom.Units.ToString().ToLower();
            }
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }

      /// <summary>
      /// El padding es el espacio de relleno que hay despues del espacio dejado por los margenes, y el espacio que hay
      /// entre la lineas y el texto de cada celda usando objetos tipo Unit del tipo C1.Preview
      /// </summary>
      /// <param name="_padding_all">Espacio para todos los lados del reporte</param>
      /// <param name="_cell_padding_all">Espacio de todos los lados de cada celda</param>
      /// <example>El siguiente ejemplo no smuestar la forma de usar la funcion de los espacios.
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setStyle(NSEStyle.modern, false);
      /// x.setPaddingAll(new Unit(5.0, UnitTypeEnum.Mm), new Unit(5.0, UnitTypeEnum.Mm));</code></example>
      public void setPaddingTodos(Unit _padding_all, Unit _cell_padding_all)
      {
         try
         {
            if (m_style != null)
            {
               m_style.PaddingTodos = _padding_all.Value.ToString() + _padding_all.Units.ToString().ToLower();
               m_style.PaddingCeldaTodos = _cell_padding_all.Value.ToString() + _cell_padding_all.Units.ToString().ToLower();
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      #endregion

      #region Fuente
      /// <summary>
      /// Definir la fuente del reporte, con datos directos
      /// </summary>
      /// <param name="_font_type">Tipo de fuente, nombre de la fuente: "Courier New"</param>
      /// <param name="_font_size">Tamaño de la fuente</param>
      /// <param name="_style">Estilo de la fuente: Bold, Regular, etc.</param>
      /// <example>El siguiente ejemplo muestra la forma de colocar una fuente al reporte
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setStyle(NSEStyle.modern, false);
      /// x.setFont("Courier New", 12, FontStyle.Italic);</code></example>
      public void setFuente(string _font_type, int _font_size, FontStyle _style)
      {
         try
         {
            if (m_style != null)
               m_style.Fuente = new Font(_font_type, _font_size, _style);
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }

      /// <summary>
      /// Definir la fuente del reporte, con un objeto tipo fuente
      /// </summary>
      /// <param name="_font">Objeto tipo fuente</param>
      /// <example>El siguiente ejemplo muestra como colocar la fuente del reporte, usando un objeto
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setStyle(NSEStyle.modern, false);
      /// Font f = new Font("Courier New", 12, FontStyle.Italic);
      /// x.setFont(f);</code></example>
      public void setFuente(Font _font)
      {
         try
         {
            if (m_style != null)
               m_style.Fuente = _font;
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }
      #endregion

      /// <summary>
      /// Definir el estilo del documento reporte.
      /// </summary>
      /// <param name="_style">Estilo predefinido del reporte: Classic, Modern y Elegant</param>
      /// <param name="_landscape">Posicion de la hoja: True: Horizontal; False: Vertical</param>
      /// <remarks>Cada uno de los estilos los podemos describir de la seguiente forma:
      /// <para>Classic</para>Este estilo se describe en las tablas, las cuales se mostraran con todas las lineas disponibles de la tabla, es decir
      /// la lineas horizontales y todas las lineas verticales.
      /// <para>Modern</para>Este estilo se describe con lineas horizontales en la cabecera y ninguna linea vertical.
      /// <para>Elegant</para>Este estilo se describe con lineas horizontales en la cabecera y todas las lineas verticales de las columnas. 
      /// </remarks>
      /// <example>El siguiente ejemplo muestra la forma rapida de colocar un estilo, y la disposicion de la hoja en forma horizontal.
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setStyle(NSEStyle.modern, false);</code></example>
      public void setEstilo(ACEEstilo _style, bool _landscape)
      {
         try
         {
            m_style = new ACEstilo();
            m_style.EEstilo = _style;
            m_style.HojaHorizontal = _landscape;
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede asignar el estilo escogido", ex);
         }
      }

      #endregion

      #region Coordenadas para las celdas Combinadas

      /// <summary>
      /// Colocar un listado de lista de coordenadas para unir celdas de varias grillas
      /// </summary>
      /// <param name="_mergedListList">Listado de listado de Coordenadas</param>
      /// <example>El siguiente ejemplo muestra la forma de ingresar un listado de coordenadas para varias 
      /// grillas o tablas
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// NSCellMergedListList lcell = new NSCellMergedListList();
      /// NSCellMergedList l1 = new NSCellMergedList();
      /// l1.Add(new NSCellMerged(1, 1, 2, 2));
      /// l1.Add(new NSCellMerged(3, 3, 4, 4));
      /// ...
      /// lcell.Add(l1);
      /// NSCellMergedList l2 = new NSCellMergedList();
      /// l2.Add(new NSCellMerged(1, 1, 2, 2));
      /// l2.Add(new NSCellMerged(3, 3, 4, 4));
      /// ...
      /// lcell.Add(l2);
      /// x.setListListMerged(lcell);</code></example>
      public void setCeldaCombinadaListaLista(ACCeldaCombinadaListaLista _celdaCombinadaListaLista)
      {
         try
         {
            m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista(_celdaCombinadaListaLista);
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }
      #endregion

      #region Para el factor de las tablas
      public void setFactorTable(double _factor, UnitTypeEnum _united)
      {
         try
         {
            if (m_style == null) m_style = new ACEstilo();
            m_style.Factor = new ACTablaAncho(_factor, _united);
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }
      public void setFactorMultiTablas(ACTablaAncho[] _anchosTablas)
      {
         try
         {
            m_style.FactorMulti = _anchosTablas;
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }
      #endregion

      #region Para alinear columnas

      /// <summary>
      /// Colocar propiedades a una grilla
      /// </summary>
      /// <param name="align_columns">Arreglo con la alineacion de columnas</param>
      /// <param name="size_columns">Tamaño de las celdas de las columnas</param>
      /// <param name="x_col">Numero de columnas</param>
      /// <example>El siguiente ejemplo muestra la forma como colocar propiedades a las columnas de una grilla
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// AlignHorzEnum[] align = { AlignHorzEnum.Center, AlignHorzEnum.Left, AlignHorzEnum.Right };
      /// Unit[] size = { new Unit(2, UnitTypeEnum.Cm), new Unit(1, UnitTypeEnum.Cm) };
      /// 
      /// x.setForColumns(align, size, _flex.Cols.Count - 1);</code></example>
      public void setAlinearParaColumnas(AlignHorzEnum[] align_columns, Unit[] size_columns, int x_col)
      {
         try
         {
            m_columnaAlineacion = new ACColumnaAlineacion(align_columns, x_col);
            m_columnaAlineacion.Ancho = size_columns;
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }

      /// <summary>
      /// arreglo de los Formatos de las columnas de una grilla
      /// </summary>
      /// <param name="m_format">Arreglo de formatos</param>
      /// <example>Muestra la forma de colocar formatos a las columnas
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// String[] format = { "N", "N", "N" };
      /// x.setFormatColumns(format);</code></example>
      public void setFormatosColumnas(String[] m_format)
      {
         try
         {
            if (m_columnaAlineacion == null) m_columnaAlineacion = new ACColumnaAlineacion();
            m_columnaAlineacion.Formato = m_format;
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }

      /// <summary>
      /// Lista de arreglos de de los formatos de las columnas
      /// </summary>
      /// <remarks>
      /// Remarcado
      /// </remarks>
      /// <param name="_listalign">Lista de arreglos</param>
      /// <example>
      /// Podemos ver el siguiente ejemplo en
      /// <para>C#</para>
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// AlignHorzEnum[] align1 = { AlignHorzEnum.Center, AlignHorzEnum.Left, AlignHorzEnum.Right };
      /// Unit[] size1 = { new Unit(2, UnitTypeEnum.Cm), new Unit(1, UnitTypeEnum.Cm) };
      /// String[] format1 = { "N", "N", "N" };
      /// NSReportColumn s = new NSReportColumn();
      /// 
      /// s.ColumnsAlign = align1;
      /// s.FormatColumns = format1;
      /// s.WidthColumns = size1;
      /// 
      /// AlignHorzEnum[] align2 = { AlignHorzEnum.Center, AlignHorzEnum.Left, AlignHorzEnum.Right };
      /// Unit[] size2 = { new Unit(2, UnitTypeEnum.Cm), new Unit(1, UnitTypeEnum.Cm) };
      /// String[] format2 = { "N", "N", "N" };
      /// 
      /// NSReportColumn s2 = new NSReportColumn();
      /// s2.ColumnsAlign = align2;
      /// s2.FormatColumns = format2;
      /// s2.WidthColumns = size2;
      /// 
      /// NSReportColumnList r = new NSReportColumnList();
      /// r.Add(new NSReportColumn(align1, _flex1.Cols.Count - 1));
      /// r.Add(new NSReportColumn(align2, _flex2.Cols.Count - 1));
      /// 
      /// x.setListForColumnas(r);
      /// </code>
      /// </example>
      public void setListaParaColumnas(ACColumnaAlineacionLista _listalign)
      {
         try
         {
            m_columnaAlineacionLista = new ACColumnaAlineacionLista(_listalign);
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }
      #endregion

      #region Colocar Texto en el reporte

      /// <summary>
      /// Colocar un texto en el reporte
      /// </summary>
      /// <param name="_text">Texto</param>
      /// <example>El siguiente ejemplo nos muestra la forma de colocar un texto
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.setText("Comentarios");</code></example>
      public void setTexto(StringBuilder _text)
      {
         try
         {
            m_texto = new ACTexto(_text);
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }

      /// <summary>
      /// Listado de textos para se colocados en el reporte, tiene que tener en cuenta que cada texto
      /// se intercala con las grillas
      /// </summary>
      /// <param name="_text">Objeto para contener cadenas de texto.</param>
      /// <example>El siguiente ejemplo muestra como ingresar un conjunto de textos intercalados con las tablas
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// x.NSTextList = new NSReportTextList();
      /// x.NSTextList.Add("Comentario Uno");
      /// x.NSTextList.Add("Comentario Dos");</code></example>
      public void setListaTexto(ACTextoLista _text)
      {
         try
         {
            m_textoLista = new ACTextoLista(_text);
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }

      #endregion

      #region Ejecucion del Reporte    
      /// <summary>
      /// Ejecuta el reporte con un listado de Grillas tipo C1FlexGrid
      /// </summary>
      /// <param name="_lflex">Listado de C1FlexGrid</param>
      /// <example>El siguiente ejemplo muestra los ejecutar el reporte de un listado de Grillas
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// NSListFlex f = new NSListFlex();
      /// f.Add(_flex1);
      /// f.Add(_flex2);
      /// f.Add(_flex3);
      /// ...
      /// x.execute(f);
      /// x.ShowDialog();</code></example>
      public void ACEjecutar(ACListaFlex _lflex)
      {
         try
         {
            if (m_style == null) m_style = new ACEstilo();
            m_style.EEstilo = ACEEstilo.elegant;
            m_style.HojaHorizontal = false;
            m_listaC1FlexGrid = new ACListaFlex(_lflex);
            if (m_columnaAlineacionLista == null) m_columnaAlineacionLista = new ACColumnaAlineacionLista();
            if (m_celdaCombinadaListaLista == null) m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();
            if (m_margen == null) m_margen = new ACMargen();
            
            ACEjecutar();
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }

      /// <summary>
      /// Ejecuta el reporte con un listado de grillas y el estilo con el que se mostrara la grilla
      /// </summary>
      /// <param name="_lflex">Listado de C1FlexGrid</param>
      /// <param name="_style">Estilo del reporte, solo afecta a las grillas</param>
      /// <example>El siguiente ejemplo colocar un listado de grillas y el estilo que tendra cada grilla
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// NSListFlex f = new NSListFlex();
      /// f.Add(_flex1);
      /// f.Add(_flex2);
      /// f.Add(_flex3);
      /// ...
      /// x.execute(f, NSEStyle.modern);
      /// </code></example>
      public void ACEjecutar(ACListaFlex _lflex, ACEEstilo _style)
      {
         try
         {
            if (m_style == null) m_style = new ACEstilo();
            m_style.EEstilo = _style;
            m_style.HojaHorizontal = false;
            m_listaC1FlexGrid = new ACListaFlex(_lflex);
            if (m_celdaCombinadaListaLista == null) m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();
            if (m_margen == null) m_margen = new ACMargen();
            
            ACEjecutar();
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }

      /// <summary>
      /// Ejecuta el reporte usando un control DataSet, es decir un conjunto de tablas que se convertiran
      /// en grillas en el reportes
      /// </summary>
      /// <param name="x_data">DataSet: conjunto de tablas</param>
      /// <example>El siguiente ejemplo muestra como usar un objeto tipo Table
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// DataTable dt = new DataTable();
      /// dt = getDatatable();
      /// x.execute(dt);</code></example>
      public void ACEjecutar(DataTable x_data)
      {
         try
         {
            if (m_style == null) m_style = new ACEstilo();
            m_style.EEstilo = ACEEstilo.elegant;
            m_style.HojaHorizontal = false;
            C1FlexGrid m_flex = new C1FlexGrid();
            crearFlex(x_data, ref m_flex);
            m_listaC1FlexGrid = new ACListaFlex();
            m_listaC1FlexGrid.Add(m_flex);
            if (m_margen == null) m_margen = new ACMargen();
            
            ACEjecutar();
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }

      /// <summary>
      /// Ejecuta el reporte usando un control DataTable, es decir una tabla que se convertiran
      /// en una grilla en el reporte, y el estilo que usara este
      /// </summary>
      /// <param name="x_data">DataTable: Tabla a ser usada para convertirse en grilla</param>
      /// <param name="_style">Estilo que mostrara las grillas</param>
      /// <example>Este ejemplo muestra la forma de crear un objeto tabla, y el estilo que tendra la tabla en el reporte
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// DataTable dt = new DataTable();
      /// dt = getDatatable();
      /// x.execute(dt, NSEStyle.modern);</code></example>
      public void ACEjecutar(DataTable x_data, ACEEstilo _style)
      {
         try
         {
            if (m_style == null) m_style = new ACEstilo();
            m_style.EEstilo = _style;
            m_style.HojaHorizontal = false;
            C1FlexGrid m_flex = new C1FlexGrid();
            crearFlex(x_data, ref m_flex);
            m_listaC1FlexGrid = new ACListaFlex();
            m_listaC1FlexGrid.Add(m_flex);
            if (m_celdaCombinadaListaLista == null) m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();            
            if (m_margen == null) m_margen = new ACMargen();
            
            ACEjecutar();
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }

      /// <summary>
      /// Ejecuta el reporte usando un control DataSet, es decir un conjunto de tablas que se convertiran
      /// en grillas en el reporte
      /// </summary>
      /// <param name="x_data">DataSet: Conjunto de tablas</param>
      /// <example>El siguiente ejemplo muestra como ejecutar el reporte con un conjunto de tablas, con un 
      /// objeto contenedor de tablas
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// DataTable ds = new DataTable();
      /// ds = getDataSet();
      /// x.execute(ds);</code></example>
      public void ACEjecutar(DataSet x_data)
      {
         try
         {
            if (m_style == null) m_style = new ACEstilo();
            m_style.EEstilo = ACEEstilo.elegant;
            m_style.HojaHorizontal = false;

            for (int i = 0; i < x_data.Tables.Count; i++)
            {
               m_listaC1FlexGrid.Add(crearFlex(x_data.Tables[i]));
            }

            if (m_celdaCombinadaListaLista == null) m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();
            if (m_margen == null) m_margen = new ACMargen();
            
            
            ACEjecutar();
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }

      /// <summary>
      /// Ejecuta el reporte usando un control DataSet, es decir un conjunto de tablas que se convertiran
      /// en grillas en el reporte, y el estilo que usaran estas tablas
      /// </summary>
      /// <param name="x_data">DataSet: Conjunto de tablas</param>
      /// <param name="_style">Estilo que se usara en el reporte</param>
      /// <example>El siguiente ejemplo muestra como ejecitar el reporte con un conjunto de tablas, con un objeto
      /// contenedor de tablas, asi como el estilo con el que se mostrara en el reporte
      /// <code>nsPreview x = new nsPreview();
      /// ...
      /// DataTable ds = new DataTable();
      /// ds = getDataSet();
      /// x.execute(ds, NSEStyle.modern);</code></example>
      public void ACEjecutar(DataSet x_data, ACEEstilo _style)
      {
         try
         {
            if (m_style == null) m_style = new ACEstilo();
            m_style.EEstilo = _style;
            m_style.HojaHorizontal = false;
            for (int i = 0; i < x_data.Tables.Count; i++)
            {
               m_listaC1FlexGrid.Add(crearFlex(x_data.Tables[i]));
            }

            if (m_celdaCombinadaListaLista == null) m_celdaCombinadaListaLista = new ACCeldaCombinadaListaLista();
            if (m_margen == null) m_margen = new ACMargen();
            
            
            ACEjecutar();
         }
         catch (Exception ex)
         {
             ACDialogos.ACMostrarMensajeError("Previsualizar Reporte", "No puede ejecutar el reporte", ex);
         }
      }

      /// <summary>
      /// Metodo publico que inicia la generacion del reporte usando un flexgrid
      /// </summary>
      public void ACEjecutar()
      {
         try
         {
            InicializarVariables();
            EjecutarMulti(printDocument);
            printDocument.Reflow();
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      #endregion
      #endregion

      #region Eventos
      /// <summary>
      /// Metodo para construir el reporte usando un Objeto PrintDocument, y una lista de 
      /// objetos, como varios Tables o Flex's
      /// </summary>
      /// <param name="doc">Objeto PrintPreview para contruir el reporte</param>
      private void EjecutarMulti(C1PrintDocument doc)
      {
         try
         {
            doc.Clear();
            doc.Style.Padding.Bottom = m_style.PaddingAbajo;
            doc.Style.Padding.Top = m_style.PaddingArriba;
            doc.Style.Padding.Left = m_style.PaddingIzquierda;
            doc.Style.Padding.Right = m_style.PaddingDerecha;

            doc.PageLayout.PageSettings.PaperKind = m_tipoPapel;
            doc.PageLayout.Document.DefaultUnit = UnitTypeEnum.Cm;
            doc.PageLayout.PageSettings.BottomMargin = m_margen.Abajo;
            doc.PageLayout.PageSettings.TopMargin = m_margen.Arriba;
            doc.PageLayout.PageSettings.LeftMargin = m_margen.Izquierda;
            doc.PageLayout.PageSettings.RightMargin = m_margen.Derecha;
            doc.PageLayout.PageSettings.Landscape = m_style.HojaHorizontal;
            doc.PageLayout.PageHeader = GenerarCabecera();
            doc.Style.Font = m_style.Fuente;

            int j = 0;
            // Recorrer los C1FlexGrid que se agregaron
            for (int i = 0; i < m_listaC1FlexGrid.ListaC1FlexGrid.Count; i++)
            {
               // Verificar el listado de textos que se agregaron para intercalarlos con la grilla C1
               if (m_textoLista != null)
               {
                  // selecciona el tipo de letra que se usara en el texto
                  RenderText rtxt = new RenderText(doc);
                  if (m_textoLista.TextoListaSB != null && i <= m_textoLista.TextoListaSB.Count && m_textoLista.TextoListaSB.Count > 0)
                  {
                     rtxt.Text = m_textoLista.TextoListaSB[i].ToString();
                     doc.Body.Children.Add(rtxt);
                  }
                  else if (m_textoLista.TextoListaAC != null && i <= m_textoLista.TextoListaAC.Count && m_textoLista.TextoListaAC.Count > 0)
                  {
                     rtxt.Text = m_textoLista.TextoListaAC[i].Texto;
                     rtxt.Style.Font = m_textoLista.TextoListaAC[i].Fuente;
                     doc.Body.Children.Add(rtxt);
                  }
                  j = i;
               }
               // Crea la grilla
               RenderTable _renderTable = new RenderTable(doc);
               C1FlexGrid _tmpFlex = new C1FlexGrid();
               _tmpFlex = m_listaC1FlexGrid.ListaC1FlexGrid[i];
               ACColumnaAlineacion _tmpColumnaAlineacion = new ACColumnaAlineacion();
               double _pixel;
               // Ver si los datos para la alineacion decolumnas esta correcto
               if (m_columnaAlineacionLista != null)
               {
                  if (m_columnaAlineacionLista.Columnas.Count != 0 && m_columnaAlineacionLista.Columnas.Count > i)
                  {
                     _tmpColumnaAlineacion = m_columnaAlineacionLista.Columnas[i];
                     _pixel = ConfigurarGrilla(ref _renderTable, ref _tmpFlex, _tmpColumnaAlineacion);
                  }
                  else
                  {
                     _pixel = ConfigurarGrilla(ref _renderTable, ref _tmpFlex);
                  }
               }
               else
               {
                  _pixel = ConfigurarGrilla(ref _renderTable, ref _tmpFlex);
               }
               // Factores para reducir el ancho de la tabla construida
               if (m_style.FactorMulti != null)
               {
                  if (m_style.FactorMulti.Length != 0 && m_style.FactorMulti.Length > i)
                  {
                     _renderTable.Width = new Unit(_pixel / m_style.FactorMulti[i].Factor, m_style.FactorMulti[i].TypeUnit);
                  }
                  else
                  {
                     _renderTable.Width = new Unit(_pixel / m_anchoTabla.Factor, m_anchoTabla.TypeUnit);
                  }
               }
               else
               {
                  _renderTable.Width = new Unit(_pixel / m_anchoTabla.Factor, m_anchoTabla.TypeUnit);
               }
               // Obtener la celdas que se encuentran combinadas
               ACCeldaCombinadaLista _tmpCeldaCombinadaLista = new ACCeldaCombinadaLista();
               if (m_celdaCombinadaListaLista.CeldaCombinadaLista.Count != 0)
               {
                  _tmpCeldaCombinadaLista = m_celdaCombinadaListaLista.CeldaCombinadaLista[i];
               }
               foreach (CellRange item in _tmpFlex.MergedRanges)
               {
                  _tmpCeldaCombinadaLista.Add(new ACCeldaCombinada(item.TopRow, item.LeftCol, item.BottomRow, item.RightCol));
               }
               
               // Generar la Grilla
               GenerarGrilla(ref doc, ref _renderTable, ref _tmpFlex, _tmpCeldaCombinadaLista, ref _tmpColumnaAlineacion);
               _renderTable.RowGroups[0, 1].Header = TableHeaderEnum.None;
               _renderTable.RowGroups[0, 1].Header = TableHeaderEnum.All;

               for (int w = 0; w < _tmpFlex.Cols.Count; w++)
               {
                  _renderTable.Rows[0][w].Style.TextAlignHorz = AlignHorzEnum.Center;
                  _renderTable.Rows[0][w].Style.TextAlignVert = AlignVertEnum.Center;
               }

               doc.Body.Children.Add(_renderTable);
            }
            if (m_textoLista != null)
            {
               for (int i = j + 1; i < m_textoLista.TextoListaSB.Count; i++)
               {
                  RenderText rtxt = new RenderText(doc) { Text = m_textoLista.TextoListaSB[i].ToString() };
                  doc.Body.Children.Add(rtxt);
               }
               for (int i = j + 1; i < m_textoLista.TextoListaAC.Count; i++)
               {
                  RenderText rtxt = new RenderText(doc) { Text = m_textoLista.TextoListaAC[i].Texto };
                  rtxt.Style.Font = m_textoLista.TextoListaAC[i].Fuente;
                  doc.Body.Children.Add(rtxt);
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      private Unit convertToX(double _px)
      {
         try
         {
            Unit u = new Unit(_px / m_style.Factor.Factor, m_style.Factor.TypeUnit);
            return u;
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      /// <summary>
      /// Función que genera el conjunto de datos, segun el flexgrid obtenido
      /// </summary>
      /// <param name="_doc">Objeto Contenedor del reporte</param>
      /// <param name="_rt">Objeto que contiene los dato en forma de Grid</param>
      /// <param name="_flex">Objeto Flex que contiene los datos</param>
      /// <param name="_cell">Objeto que contiene el conjunto de celdas fusionadas, contiene las coordenadas
      ///  de el inicio y el fin de las celdas que fueron fusionadas</param>
      private void GenerarGrilla(ref C1PrintDocument _doc, ref RenderTable _rt, ref C1FlexGrid _flex, ACCeldaCombinadaLista _cell, ref ACColumnaAlineacion x_align)
      {
         try
         {
            for (int row = 0; row < _flex.Rows.Count; row++)
            {
               if (_flex.Rows.Fixed > row)
               {
                  _rt.Rows[row].Style.GridLines.Top = m_style.LineaEstilo;
                  _rt.Rows[row].Style.GridLines.Bottom = m_style.LineaEstilo;
                  _rt.Rows[row].Style.Font = new Font(m_style.FuenteTipo, m_style.FuenteTamano, FontStyle.Bold);
               } else if (_flex.Rows[row].IsNode)
               {
                  _rt.Rows[row].Style.GridLines.Top = m_style.LineaEstilo;
                  _rt.Rows[row].Style.GridLines.Bottom = m_style.LineaEstilo;
                  _rt.Rows[row].Style.Font = new Font(m_style.FuenteTipo, m_style.FuenteTamano, FontStyle.Bold);
               }
               for (int col = 0; col < _flex.Cols.Count; col++)
               {
                  try
                  {
                     if (_flex[row, col] != null)
                     {
                        RenderText celltext = new RenderText(_doc);
                        switch (_flex[row, col].GetType().ToString())
                        {
                           case "System.String":
                              celltext.Text = (_flex[row, col] != null) ? _flex[row, col].ToString() : "";
                              _rt.Cells[row, col].RenderObject = celltext;
                              _rt.Cells[row, col].Style.TextAlignHorz = AlignHorzEnum.Left;
                              break;
                           case "System.Int16":
                           case "System.Nullable`1[System.Int16]":
                              celltext.Text = getTextWithFormatInt16(row, col, ref _flex, x_align);
                              _rt.Cells[row, col].RenderObject = celltext;
                              _rt.Cells[row, col].Style.TextAlignHorz = AlignHorzEnum.Right;
                              break;
                           case "System.Int32":
                           case "System.Nullable`1[System.Int32]":
                              celltext.Text = getTextWithFormatInt32(row, col, ref _flex, x_align);
                              _rt.Cells[row, col].RenderObject = celltext;
                              _rt.Cells[row, col].Style.TextAlignHorz = AlignHorzEnum.Right;
                              break;
                           case "System.Int64":
                           case "System.Nullable`1[System.Int64]":
                              celltext.Text = getTextWithFormatInt64(row, col, ref _flex, x_align);
                              _rt.Cells[row, col].RenderObject = celltext;
                              _rt.Cells[row, col].Style.TextAlignHorz = AlignHorzEnum.Right;
                              break;
                           case "System.Double":
                           case "System.Nullable`1[System.Double]":
                              celltext.Text = getTextWithFormatDouble(row, col, ref _flex, x_align);
                              _rt.Cells[row, col].RenderObject = celltext;
                              _rt.Cells[row, col].Style.TextAlignHorz = AlignHorzEnum.Right;
                              break;
                           case "System.Decimal":
                           case "System.Nullable`1[System.Decimal]":
                              celltext.Text = getTextWithFormatDecimal(row, col, ref _flex, x_align);
                              _rt.Cells[row, col].RenderObject = celltext;
                              _rt.Cells[row, col].Style.TextAlignHorz = AlignHorzEnum.Right;
                              break;
                           case "System.DateTime":
                           case "System.Nullable`1[System.DateTime]":
                              celltext.Text = (_flex[row, col] != null) ?  ((DateTime)(_flex[row, col])).ToString(_flex.Cols[col].Format) : "";
                              _rt.Cells[row, col].RenderObject = celltext;
                              _rt.Cells[row, col].Style.TextAlignHorz = AlignHorzEnum.Left;
                              break;
                           case "System.Boolean":
                           case "System.Nullable`1[System.Boolean]":
                              celltext.Text = (_flex[row, col] == null) ? "-": (((Boolean)_flex[row, col])?"Si" : "No");
                              _rt.Cells[row, col].RenderObject = celltext;
                              _rt.Cells[row, col].Style.TextAlignHorz = AlignHorzEnum.Center;
                              break;
                           default:
                              celltext.Text = (_flex[row, col] != null) ? _flex[row, col].ToString() : "";
                              _rt.Cells[row, col].RenderObject = celltext;
                              _rt.Cells[row, col].Style.TextAlignHorz = AlignHorzEnum.Left;
                              break;
                        }
                     }
                     else
                     {
                        _rt.Cells[row, col].Style.TextAlignHorz = AlignHorzEnum.Left;
                     }

                     if (x_align != null && x_align.Alineacion != null && x_align.Alineacion.Length != 0)
                     {
                        _rt.Cells[row, col].Style.TextAlignHorz = x_align.Alineacion.Length <= col ? x_align.Alineacion[x_align.Alineacion.Length - 1] : x_align.Alineacion[col];
                     }
                  }
                  catch (Exception ex)
                  {
                     throw ex;
                  }
               }
            }
            if (_cell.CeldaCombinada.Count > 0)
            {
               foreach (ACCeldaCombinada Item in _cell.CeldaCombinada)
               {
                  _rt.Cells[Item.FilaArriba, Item.ColumnaIzquierda].SpanCols = Item.ColumnaDerecha - Item.ColumnaIzquierda + 1;
                  _rt.Cells[Item.FilaArriba, Item.ColumnaIzquierda].SpanRows = Item.FilaAbajo - Item.FilaArriba + 1;
               }
            }
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      private string getTextWithFormatDecimal(int row, int col, ref C1FlexGrid _flex, ACColumnaAlineacion x_align)
      {
         String _value = "";
         if (x_align != null && x_align.Formato != null && x_align.Formato.Length != 0)
         {
            if (x_align.Formato.Length >= col)
            {
               _value = (_flex[row, col] != null) ? ((Decimal)(_flex[row, col])).ToString(x_align.Formato[col == 0 ? col : col - 1].ToString()) : "";
            }
            else
            {
               _value = (_flex[row, col] != null) ? ((Decimal)(_flex[row, col])).ToString(_flex.Cols[col].Format.ToString()) : "";
            }
         }
         else
         {
            _value = (_flex[row, col] != null) ? ((Decimal)(_flex[row, col])).ToString(_flex.Cols[col].Format.ToString()) : "";
         }
         return _value;
      }
      private string getTextWithFormatInt32(int row, int col, ref C1FlexGrid _flex, ACColumnaAlineacion x_align)
      {
         String _value = "";
         if (x_align != null && x_align.Formato != null && x_align.Formato.Length != 0)
         {
            if (x_align.Formato.Length >= col)
            {
               _value = (_flex[row, col] != null) ? ((Int32)(_flex[row, col])).ToString(x_align.Formato[col == 0 ? col : col - 1].ToString()) : "";
            }
            else
            {
               _value = (_flex[row, col] != null) ? ((Int32)(_flex[row, col])).ToString(_flex.Cols[col].Format.ToString()) : "";
            }
         }
         else
         {
            _value = (_flex[row, col] != null) ? ((Int32)(_flex[row, col])).ToString(_flex.Cols[col].Format.ToString()) : "";
         }
         return _value;
      }
      private string getTextWithFormatInt16(int row, int col, ref C1FlexGrid _flex, ACColumnaAlineacion x_align)
      {
         String _value = "";
         if (x_align != null && x_align.Formato != null && x_align.Formato.Length != 0)
         {
            if (x_align.Formato.Length >= col)
            {
               _value = (_flex[row, col] != null) ? ((Int16)(_flex[row, col])).ToString(x_align.Formato[col == 0 ? col : col - 1].ToString()) : "";
            }
            else
            {
               _value = (_flex[row, col] != null) ? ((Int16)(_flex[row, col])).ToString(_flex.Cols[col].Format.ToString()) : "";
            }
         }
         else
         {
            _value = (_flex[row, col] != null) ? ((Int16)(_flex[row, col])).ToString(_flex.Cols[col].Format.ToString()) : "";
         }
         return _value;
      }
      private string getTextWithFormatDouble(int row, int col, ref C1FlexGrid _flex, ACColumnaAlineacion x_align)
      {
         String _value = "";
         if (x_align != null && x_align.Formato != null && x_align.Formato.Length != 0)
         {
            if (x_align.Formato.Length >= col)
            {
               _value = (_flex[row, col] != null) ? ((Double)(_flex[row, col])).ToString(x_align.Formato[col == 0 ? col : col - 1].ToString()).ToString() : "";
            }
            else
            {
               _value = (_flex[row, col] != null) ? ((Double)(_flex[row, col])).ToString(_flex.Cols[col].Format.ToString()).ToString() : "";
            }
         }
         else
         {
            _value = (_flex[row, col] != null) ? ((Double)(_flex[row, col])).ToString(_flex.Cols[col].Format.ToString()).ToString() : "";
         }
         return _value;
      }
      private string getTextWithFormatInt64(int row, int col, ref C1FlexGrid _flex, ACColumnaAlineacion x_align)
      {
         String _value = "";
         if (x_align != null && x_align.Formato != null && x_align.Formato.Length != 0)
         {
            if (x_align.Formato.Length >= col)
            {
               _value = (_flex[row, col] != null) ? ((Int64)(_flex[row, col])).ToString(x_align.Formato[col == 0 ? col : col - 1].ToString()) : "";
            }
            else
            {
               _value = (_flex[row, col] != null) ? ((Int64)(_flex[row, col])).ToString(_flex.Cols[col].Format.ToString()) : "";
            }
         }
         else
         {
            _value = (_flex[row, col] != null) ? ((Int64)(_flex[row, col])).ToString(_flex.Cols[col].Format.ToString()) : "";
         }
         return _value;
      }

      /// <summary>
      /// Funcion para definir el estilo de el conjunto de datos en forma de Grid
      /// </summary>
      /// <param name="_rt">Objeto que contiene los datos en forma de grid</param>
      /// <param name="_flex">Flex que contiente los datos a ser pasados a "_rt"</param>
      private double ConfigurarGrilla(ref RenderTable _rt, ref C1FlexGrid _flex)
      {
         try
         {
            return ConfigurarGrilla(ref _rt, ref _flex, null);
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }
      /// <summary>
      /// Funcion para definir el estilo de el conjunto de datos en forma de Grid
      /// </summary>
      /// <param name="_rt">Objeto que contiene los datos en forma de grid</param>
      /// <param name="_flex">Flex que contiente los datos a ser pasados a "_rt"</param>
      /// <param name="x_align"></param>
      private double ConfigurarGrilla(ref RenderTable _rt, ref C1FlexGrid _flex, ACColumnaAlineacion x_align)
      {
         try
         {
            _rt.StretchColumns = StretchTableEnum.None;
            _rt.Rows[0].Style.Font = new Font(m_style.FuenteTipo, m_style.FuenteTamano, FontStyle.Bold);
            _rt.Rows[0].Style.TextAlignHorz = AlignHorzEnum.Center;
            _rt.Rows[0].Style.TextAlignVert = AlignVertEnum.Center;

            double px = 0;
            for (int col = 0; col < _flex.Cols.Count; col++)
            {
               _rt.Cols[col].CellStyle.TextAlignHorz = AlignHorzEnum.Center;
               _rt.Cols[col].CellStyle.TextAlignVert = AlignVertEnum.Center;
               _rt.Cols[col].CellStyle.Padding.Left = m_style.PaddingCeldaIzquierda;
               _rt.Cols[col].CellStyle.Padding.Right = m_style.PaddingCeldaDerecha;
               _rt.Cols[col].CellStyle.Padding.Top = m_style.PaddingCeldaArriba;
               _rt.Cols[col].CellStyle.Padding.Bottom = m_style.PaddingCeldaAbajo;
               Unit tmp;

               if (x_align != null && x_align.Ancho != null && x_align.Ancho.Length != 0 && x_align.Ancho.Length > col)
               {
                  if (x_align.Ancho[col].Value != -1)
                  {
                     tmp = new Unit(ACUtilitarios.ConvertToPx(x_align.Ancho[col].Value, x_align.Ancho[col].Units), UnitTypeEnum.Pixel);
                  }
                  else
                  {
                     tmp = new Unit(_flex.Cols[col].WidthDisplay, UnitTypeEnum.Pixel);
                  }
               }
               else
               {
                  tmp = new Unit(_flex.Cols[col].WidthDisplay, UnitTypeEnum.Pixel);
               }

               switch (m_style.EEstilo)
               {
                  case ACEEstilo.classicc:
                     _rt.Cols[col].SizingMode = TableSizingModeEnum.Fixed;
                     _rt.Cols[col].Width = tmp;
                     _rt.Cols[col].Style.GridLines.All = m_style.LineaEstilo;
                     _rt.Cols[col].SizingMode = TableSizingModeEnum.Fixed;
                     px += ACUtilitarios.ConvertToCm(tmp.Value, tmp.Units);
                     break;
                  case ACEEstilo.elegant:
                     _rt.Cols[col].SizingMode = TableSizingModeEnum.Fixed;
                     _rt.Cols[col].Width = tmp;
                     _rt.Cols[col].Style.GridLines.Top = m_style.LineaEstilo;
                     _rt.Cols[col].Style.GridLines.Bottom = m_style.LineaEstilo;
                     _rt.Cols[col].Style.GridLines.Left = m_style.LineaEstilo;
                     _rt.Cols[col].Style.GridLines.Right = m_style.LineaEstilo;
                     _rt.Rows[0].Style.GridLines.Bottom = m_style.LineaEstilo;
                     _rt.Cols[col].SizingMode = TableSizingModeEnum.Fixed;
                     px += ACUtilitarios.ConvertToCm(tmp.Value, tmp.Units);
                     break;
                  case ACEEstilo.modern:
                     _rt.Cols[col].SizingMode = TableSizingModeEnum.Fixed;
                     _rt.Cols[col].Width = tmp;
                     _rt.Cols[col].Style.GridLines.Top = m_style.LineaEstilo;
                     _rt.Cols[col].Style.GridLines.Bottom = m_style.LineaEstilo;
                     _rt.Rows[0].Style.GridLines.Bottom = m_style.LineaEstilo;
                     _rt.Cols[col].SizingMode = TableSizingModeEnum.Fixed;
                     px += ACUtilitarios.ConvertToCm(tmp.Value, tmp.Units);
                     break;
                  default:
                     _rt.Cols[col].SizingMode = TableSizingModeEnum.Fixed;
                     _rt.Cols[col].Width = tmp;
                     _rt.Cols[col].Style.GridLines.All = m_style.LineaEstilo;
                     _rt.Cols[col].SizingMode = TableSizingModeEnum.Fixed;
                     px += ACUtilitarios.ConvertToCm(tmp.Value, tmp.Units);
                     break;
               }
            }
            return px;
         }
         catch (Exception ex)
         {
            throw ex;
         }
      }

      #endregion
   }
}
